home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / pyclbr.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  10KB  |  343 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """Parse a Python module and describe its classes and methods.
  5.  
  6. Parse enough of a Python file to recognize imports and class and
  7. method definitions, and to find out the superclasses of a class.
  8.  
  9. The interface consists of a single function:
  10.         readmodule_ex(module [, path])
  11. where module is the name of a Python module, and path is an optional
  12. list of directories where the module is to be searched.  If present,
  13. path is prepended to the system search path sys.path.  The return
  14. value is a dictionary.  The keys of the dictionary are the names of
  15. the classes defined in the module (including classes that are defined
  16. via the from XXX import YYY construct).  The values are class
  17. instances of the class Class defined here.  One special key/value pair
  18. is present for packages: the key '__path__' has a list as its value
  19. which contains the package search path.
  20.  
  21. A class is described by the class Class in this module.  Instances
  22. of this class have the following instance variables:
  23.         module -- the module name
  24.         name -- the name of the class
  25.         super -- a list of super classes (Class instances)
  26.         methods -- a dictionary of methods
  27.         file -- the file in which the class was defined
  28.         lineno -- the line in the file on which the class statement occurred
  29. The dictionary of methods uses the method names as keys and the line
  30. numbers on which the method was defined as values.
  31. If the name of a super class is not recognized, the corresponding
  32. entry in the list of super classes is not a class instance but a
  33. string giving the name of the super class.  Since import statements
  34. are recognized and imported modules are scanned as well, this
  35. shouldn't happen often.
  36.  
  37. A function is described by the class Function in this module.
  38. Instances of this class have the following instance variables:
  39.         module -- the module name
  40.         name -- the name of the class
  41.         file -- the file in which the class was defined
  42.         lineno -- the line in the file on which the class statement occurred
  43. """
  44. import sys
  45. import imp
  46. import tokenize
  47. from token import NAME, DEDENT, NEWLINE
  48. from operator import itemgetter
  49. __all__ = [
  50.     'readmodule',
  51.     'readmodule_ex',
  52.     'Class',
  53.     'Function']
  54. _modules = { }
  55.  
  56. class Class:
  57.     '''Class to represent a Python class.'''
  58.     
  59.     def __init__(self, module, name, super, file, lineno):
  60.         self.module = module
  61.         self.name = name
  62.         if super is None:
  63.             super = []
  64.         
  65.         self.super = super
  66.         self.methods = { }
  67.         self.file = file
  68.         self.lineno = lineno
  69.  
  70.     
  71.     def _addmethod(self, name, lineno):
  72.         self.methods[name] = lineno
  73.  
  74.  
  75.  
  76. class Function:
  77.     '''Class to represent a top-level Python function'''
  78.     
  79.     def __init__(self, module, name, file, lineno):
  80.         self.module = module
  81.         self.name = name
  82.         self.file = file
  83.         self.lineno = lineno
  84.  
  85.  
  86.  
  87. def readmodule(module, path = []):
  88.     '''Backwards compatible interface.
  89.  
  90.     Call readmodule_ex() and then only keep Class objects from the
  91.     resulting dictionary.'''
  92.     dict = _readmodule(module, path)
  93.     res = { }
  94.     for key, value in dict.items():
  95.         if isinstance(value, Class):
  96.             res[key] = value
  97.             continue
  98.     
  99.     return res
  100.  
  101.  
  102. def readmodule_ex(module, path = []):
  103.     '''Read a module file and return a dictionary of classes.
  104.  
  105.     Search for MODULE in PATH and sys.path, read and parse the
  106.     module and return a dictionary with one entry for each class
  107.     found in the module.
  108.  
  109.     If INPACKAGE is true, it must be the dotted name of the package in
  110.     which we are searching for a submodule, and then PATH must be the
  111.     package search path; otherwise, we are searching for a top-level
  112.     module, and PATH is combined with sys.path.
  113.     '''
  114.     return _readmodule(module, path)
  115.  
  116.  
  117. def _readmodule(module, path, inpackage = None):
  118.     '''Do the hard work for readmodule[_ex].'''
  119.     if inpackage:
  120.         fullmodule = '%s.%s' % (inpackage, module)
  121.     else:
  122.         fullmodule = module
  123.     if fullmodule in _modules:
  124.         return _modules[fullmodule]
  125.     
  126.     dict = { }
  127.     if module in sys.builtin_module_names and not inpackage:
  128.         _modules[module] = dict
  129.         return dict
  130.     
  131.     i = module.rfind('.')
  132.     if i >= 0:
  133.         package = module[:i]
  134.         submodule = module[i + 1:]
  135.         parent = _readmodule(package, path, inpackage)
  136.         if inpackage:
  137.             package = '%s.%s' % (inpackage, package)
  138.         
  139.         return _readmodule(submodule, parent['__path__'], package)
  140.     
  141.     f = None
  142.     _modules[fullmodule] = dict
  143.     if type != imp.PY_SOURCE:
  144.         f.close()
  145.         return dict
  146.     
  147.     stack = []
  148.     g = tokenize.generate_tokens(f.readline)
  149.     
  150.     try:
  151.         for tokentype, token, start, end, line in g:
  152.             if tokentype == DEDENT:
  153.                 (lineno, thisindent) = start
  154.                 while stack and stack[-1][1] >= thisindent:
  155.                     del stack[-1]
  156.                 continue
  157.             if token == 'def':
  158.                 (lineno, thisindent) = start
  159.                 while stack and stack[-1][1] >= thisindent:
  160.                     del stack[-1]
  161.                 (tokentype, meth_name, start, end, line) = g.next()
  162.                 if tokentype != NAME:
  163.                     continue
  164.                 
  165.                 if stack:
  166.                     cur_class = stack[-1][0]
  167.                     if isinstance(cur_class, Class):
  168.                         cur_class._addmethod(meth_name, lineno)
  169.                     
  170.                 else:
  171.                     dict[meth_name] = Function(module, meth_name, file, lineno)
  172.                 stack.append((None, thisindent))
  173.                 continue
  174.             if token == 'class':
  175.                 (lineno, thisindent) = start
  176.                 while stack and stack[-1][1] >= thisindent:
  177.                     del stack[-1]
  178.                 (tokentype, class_name, start, end, line) = g.next()
  179.                 if tokentype != NAME:
  180.                     continue
  181.                 
  182.                 (tokentype, token, start, end, line) = g.next()
  183.                 inherit = None
  184.                 if token == '(':
  185.                     names = []
  186.                     level = 1
  187.                     super = []
  188.                     while True:
  189.                         (tokentype, token, start, end, line) = g.next()
  190.                         if token in (')', ',') and level == 1:
  191.                             n = ''.join(super)
  192.                             if n in dict:
  193.                                 n = dict[n]
  194.                             else:
  195.                                 c = n.split('.')
  196.                                 if len(c) > 1:
  197.                                     m = c[-2]
  198.                                     c = c[-1]
  199.                                     if m in _modules:
  200.                                         d = _modules[m]
  201.                                         if c in d:
  202.                                             n = d[c]
  203.                                         
  204.                                     
  205.                                 
  206.                             names.append(n)
  207.                             super = []
  208.                         
  209.                         None if token == '(' else level == 0
  210.                         if token == ',' and level == 1:
  211.                             continue
  212.                         super.append(token)
  213.                     inherit = names
  214.                 
  215.                 cur_class = Class(fullmodule, class_name, inherit, file, lineno)
  216.                 if not stack:
  217.                     dict[class_name] = cur_class
  218.                 
  219.                 stack.append((cur_class, thisindent))
  220.                 continue
  221.             if token == 'import' and start[1] == 0:
  222.                 modules = _getnamelist(g)
  223.                 for mod, mod2 in modules:
  224.                     
  225.                     try:
  226.                         if not inpackage:
  227.                             _readmodule(mod, path)
  228.                         else:
  229.                             
  230.                             try:
  231.                                 _readmodule(mod, path, inpackage)
  232.                             except ImportError:
  233.                                 _readmodule(mod, [])
  234.  
  235.                     continue
  236.                     continue
  237.  
  238.                 
  239.             if token == 'from' and start[1] == 0:
  240.                 (mod, token) = _getname(g)
  241.                 if not mod or token != 'import':
  242.                     continue
  243.                 
  244.                 names = _getnamelist(g)
  245.                 
  246.                 try:
  247.                     d = _readmodule(mod, path, inpackage)
  248.                 except:
  249.                     continue
  250.  
  251.                 for n, n2 in names:
  252.                     if n in d:
  253.                         if not n2:
  254.                             pass
  255.                         dict[n] = d[n]
  256.                         continue
  257.                     if n == '*':
  258.                         for n in d:
  259.                             if n[0] != '_':
  260.                                 dict[n] = d[n]
  261.                                 continue
  262.                         
  263.                 
  264.     except StopIteration:
  265.         pass
  266.  
  267.     f.close()
  268.     return dict
  269.  
  270.  
  271. def _getnamelist(g):
  272.     names = []
  273.     while True:
  274.         (name, token) = _getname(g)
  275.         if not name:
  276.             break
  277.         
  278.         if token == 'as':
  279.             (name2, token) = _getname(g)
  280.         else:
  281.             name2 = None
  282.         names.append((name, name2))
  283.         while token != ',' and '\n' not in token:
  284.             (tokentype, token, start, end, line) = g.next()
  285.         if token != ',':
  286.             break
  287.             continue
  288.     return names
  289.  
  290.  
  291. def _getname(g):
  292.     parts = []
  293.     (tokentype, token, start, end, line) = g.next()
  294.     if tokentype != NAME and token != '*':
  295.         return (None, token)
  296.     
  297.     parts.append(token)
  298.     while True:
  299.         (tokentype, token, start, end, line) = g.next()
  300.         if token != '.':
  301.             break
  302.         
  303.         (tokentype, token, start, end, line) = g.next()
  304.         if tokentype != NAME:
  305.             break
  306.         
  307.         parts.append(token)
  308.     return ('.'.join(parts), token)
  309.  
  310.  
  311. def _main():
  312.     import os as os
  313.     mod = sys.argv[1]
  314.     if os.path.exists(mod):
  315.         path = [
  316.             os.path.dirname(mod)]
  317.         mod = os.path.basename(mod)
  318.         if mod.lower().endswith('.py'):
  319.             mod = mod[:-3]
  320.         
  321.     else:
  322.         path = []
  323.     dict = readmodule_ex(mod, path)
  324.     objs = dict.values()
  325.     objs.sort((lambda a, b: cmp(getattr(a, 'lineno', 0), getattr(b, 'lineno', 0))))
  326.     for obj in objs:
  327.         if isinstance(obj, Class):
  328.             print 'class', obj.name, obj.super, obj.lineno
  329.             methods = sorted(obj.methods.iteritems(), key = itemgetter(1))
  330.             for name, lineno in methods:
  331.                 if name != '__path__':
  332.                     print '  def', name, lineno
  333.                     continue
  334.             
  335.         if isinstance(obj, Function):
  336.             print 'def', obj.name, obj.lineno
  337.             continue
  338.     
  339.  
  340. if __name__ == '__main__':
  341.     _main()
  342.  
  343.